import { ref, computed, h } from 'vue'
import { nanoid } from 'nanoid'
import { message } from 'ant-design-vue'
import { renderExportForm } from '../../render/ReviewRender'
import { renderHSTable } from '../../render/HSRender'
import { getReviewData, getHscode } from '@/api/api'
import { getBusinessKnowledge } from '@/api/api2'
import MarkdownIt from 'markdown-it'
const md = new MarkdownIt()

// 获取AI结果
const getRenderContent = async (nextContent, files, scene, config = {}) => {
  switch (scene) {
    case '业务知识':
      const res_businessKnowledge = await getBusinessKnowledge(
        {
          query: nextContent,
        },
        config,
      ) // 传入配置，包含 signal
      console.log('🐯 ~ getRenderContent ~ res:', res_businessKnowledge)
      return {
        message: res_businessKnowledge.data,
        sources: [
          ...res_businessKnowledge.ans,
          {
            content: '暂时无法显示',
            metadata: {
              filename: 'QR台账.csv',
            },
          },
          {
            content: '暂时无法显示',
            metadata: {
              filename: '供应商质量问题台账.csv',
            },
          },
        ],
      }
    // return {
    //   message: '业务知识',
    //   sources: [
    //     {
    //       content:
    //         '流，资金流的协同，以满足用户的需求和提高供应链的整体竞争能力。实现供应链管理有两大技术支柱：集成和协同。而供应链的协同功能以3项技术为基础：①现代的信息和通讯技术。②过程标定(基准)一以行业的最佳实践或企业的运行效果为基准模块，实行供应链改造的后来者向这个模块看齐。③高级计划与排产技术(AdvancedPlanningandScheduling，APS)。APS能够统一和协调企业间的长，中，近期的计划，是供应链管理的核心。2．1．2供应商管理供应商管理是用来改善与供应链上游供应商的关系的，它是一种致力于实现与供应商建立和维持长久，紧密伙伴关系的管理思想和软件技术的解决方案，它14052025465罗志祥汽车零部件行业供应链质量管理与探讨一基于A公rd在供应链质量管理的实践旨在改善企业与供应商之间关系的新型管理机制，实施于围绕企业采购业务相关的领域，目标是通过与供应商建立长期，紧密的业务关系，并通过对双方资源和竞争优势的整合来共同开拓市场，',
    //       metadata: {
    //         filename:
    //           'pdf_9_汽车零部件行业供应链质量管理与探讨——基于A公司在供应链质量管理的实践.docx',
    //       },
    //     },
    //     {
    //       content:
    //         '开拓市场，扩大市场需求和份额，降低产品前期的高额成本，实现双赢的企业管理模式；同时它又是以多种信息技术为支持和手段的一套先进的管理软件和技术，将先进的电子商务，数据挖掘，协同技术等信息技术紧密集成在一起，为企业产品的策略性设计，资源的策略性获取，合同的有效洽谈，产品内容的统一管理等过程提供了一个优化的解决方案。实际上，这是一种以“扩展协作互助的伙伴关系，共同开拓和扩大市场份额，实现双赢”为导向的企业资源获取管理的系统工程。供应商管理的最基本的内容包括以下几个方面，即：需求分析，供应商分类选择，战略关系发展，供应商谈判和供应商绩效评价。1)需求分析。准确，及时的需求分析是企业决策制定的一个先决条件。随着供应商队伍专业化的发展，准确及时的采购可以节省开支，取得市场上的采购优势。采购既要面对生产又要同时满足市场和客户的要求。供应商管理能够整合内部和外部资源，建立起高效能的组织采购，对自身业务关键性材料或者服务的需求进行战略部署，以减少日常生产运',
    //       metadata: {
    //         filename:
    //           'pdf_9_汽车零部件行业供应链质量管理与探讨——基于A公司在供应链质量管理的实践.pdf',
    //       },
    //     },
    //     {
    //       content:
    //         '虑供应链管理的地位具有十分重要的意义25/8/3供应链管理战略的主要内容制定供应链管理实施战略在企业内外同时采取有力措施充分发挥信息的作用供应链企业的组成和运行计算机技术和人工智能技术的广泛应用方法论的指导标准和法规的作用25/8/3供应链管理战略的主要内容（续）推动式(Push)和牵引式(Pull)的供应链图1-7两种不同性质的供应链企业采取什么样的供应链运行方式，与企业系统的基础管理水平有很大关系，切不可盲目模仿其它企业的成功做法，因为不同企业有不同的管理文化，盲目跟从反',
    //       metadata: {
    //         filename: '7_供应链管理.ppt',
    //       },
    //     },
    //   ],
    // }
    case '制单审核':
      const res_review = await getReviewData(
        {
          query: nextContent,
        },
        config,
      ) // 传入配置，包含 signal
      console.log('🐯 ~ getRenderContent ~ res:', res_review)
      return renderExportForm(res_review.data, res_review.pdf_url, res_review.pdf_size)
    case '申报要素':
      const res_hscode = await getHscode(
        {
          query: nextContent,
        },
        config,
      ) // 传入配置，包含 signal
      console.log('🐯 ~ getRenderContent ~ res:', res_hscode)
      return renderHSTable(res_hscode.data)

    default:
      return '该功能模块正在开发中...'
  }
}

export function useMessages(activeKey) {
  // 使用 Map 存储每个会话的消息
  const messagesMap = ref(new Map())
  const tempMessages = ref([])
  const content = ref('')
  const requestLoading = ref(false)
  let aiAbortController = null

  // 获取当前会话的消息
  const getCurrentMessages = (key) => {
    if (!messagesMap.value.has(key)) {
      messagesMap.value.set(key, [])
    }
    return messagesMap.value.get(key)
  }

  const BubbleItems = computed(() => {
    if (activeKey.value === null) {
      // 新对话状态，显示临时消息
      return tempMessages.value.map(formatMessage)
    } else {
      // 已有对话，显示对应消息
      const currentMessages = getCurrentMessages(activeKey.value)
      return currentMessages.map(formatMessage)
    }
  })

  watch(activeKey, (newVal, oldVal) => {
    console.log('🐯 ~ watch ~ oldVal,newVal:', oldVal, newVal)
    if (!newVal) {
    }
  })

  // const formatMessage = ({ id, message, role, loading }) => {
  //   const base = {
  //     key: id,
  //     role,
  //     loading,
  //     // footer:
  //   }

  //   if (role === 'ai') {
  //     if (typeof message === 'string') {
  //       // base.typing = { step: 2, interval: 50 }
  //       base.content = message
  //       base.onTypingComplete = () => {}
  //     } else {
  //       base.messageRender = () => h(message)
  //     }
  //   } else {
  //     base.content = message
  //   }

  //   return base
  // }

  const formatMessage = ({ id, message, role, loading }) => {
    const base = {
      key: id,
      role,
      loading,
    }

    if (role === 'ai') {
      // if (typeof message === 'string') {
      //   // 使用 content 而不是 messageRender，这样 typing 效果才能生效
      //   base.content = message
      //   // 如果需要 Markdown 渲染，可以在 roles 配置中处理
      // } else {
      //   base.messageRender = () => h(message)
      // }
      base.content = message
    } else {
      base.content = message
    }

    return base
  }

  const sendMessage = async (
    { content: nextContent, files, scene },
    isCreatingNewConversation,
    conversationsItems,
  ) => {
    if (!nextContent && (!files || !files.length)) return
    requestLoading.value = true
    console.log('🐯 ~ sendMessage ~ requestLoading.value:', requestLoading.value)
    console.log(nextContent, files, scene)
    // 第一次发送消息或在新建对话状态
    if (isCreatingNewConversation.value) {
      // 如果有文件，添加文件消息
      if (files && files.length > 0) {
        tempMessages.value.push({
          id: nanoid(),
          role: 'file',
          message: files,
        })
      }

      // 添加用户消息到临时区
      tempMessages.value.push({
        id: nanoid(),
        message: nextContent,
        role: 'local',
        loading: false,
      })

      // 添加 AI loading 消息
      const aiId = nanoid()
      tempMessages.value.push({
        id: aiId,
        message: '',
        role: 'ai',
        loading: true,
        scene: scene, // 添加场景信息
      })

      // 创建新的 AbortController
      aiAbortController = new AbortController()

      try {
        // await new Promise((resolve) => setTimeout(resolve, 1000))
        const aiReply = await getRenderContent(nextContent, files, scene, {
          signal: aiAbortController.signal, // 传入 signal
        })
        console.log('🐯 ~ sendMessage ~ aiReply:', aiReply)

        // 更新 AI 回复
        const idx = tempMessages.value.findIndex((m) => m.id === aiId)
        console.log('🐯 ~ sendMessage ~ idx:', idx)
        if (idx !== -1) {
          tempMessages.value[idx] = {
            ...tempMessages.value[idx],
            message: aiReply,
            loading: false,
            scene: scene, // 保持场景信息
          }
        }
        console.log('🐯 ~ sendMessage ~ tempMessages:', tempMessages.value)
        // AI 回复后，创建新会话
        const newKey = nanoid()
        // 使用用户第一句话作为会话标题
        const newLabel = nextContent.trim().slice(0, 10) || '新聊天'
        conversationsItems.value.push({
          key: newKey,
          label: newLabel,
        })
        // 将临时消息转移到新会话
        messagesMap.value.set(newKey, [...tempMessages.value])
        console.log('🐯 ~ sendMessage ~ messagesMap.value:', messagesMap.value)

        // 激活新会话
        activeKey.value = newKey

        // 清空临时消息与输入框
        tempMessages.value = []
        content.value = ''
      } catch (e) {
        console.log('🐯 ~ useMessages ~ e:', e)
        // 错误处理
        const idx = tempMessages.value.findIndex((m) => m.id === aiId)
        if (idx !== -1) {
          // 判断是否是取消请求导致的错误
          const message = e.name === 'CanceledError' ? '您已取消请求。' : 'AI请求失败，请重试'
          tempMessages.value[idx] = {
            ...tempMessages.value[idx],
            message,
            loading: false,
            scene: scene, // 保持场景信息
          }
        }
        if (e.name !== 'CanceledError') {
          message.error('AI请求失败')
        }
      } finally {
        requestLoading.value = false
        aiAbortController = null
      }
    } else {
      // 现有会话流程
      const currentMessages = getCurrentMessages(activeKey.value)

      // 如果有文件，添加文件消息
      if (files && files.length > 0) {
        currentMessages.push({
          id: nanoid(),
          role: 'file',
          message: files,
        })
      }

      // 添加用户消息
      const userMessage = {
        id: nanoid(),
        message: nextContent,
        role: 'local',
        loading: false,
      }
      currentMessages.push(userMessage)

      // 添加 AI 消息
      const aiId = nanoid()
      const aiMessage = {
        id: aiId,
        message: '',
        role: 'ai',
        loading: true,
        scene: scene, // 添加场景信息
      }
      currentMessages.push(aiMessage)

      // 创建新的 AbortController
      aiAbortController = new AbortController()

      try {
        // await new Promise((resolve, reject) => setTimeout(resolve, 1000))
        const aiReply = await getRenderContent(nextContent, files, scene, {
          signal: aiAbortController.signal, // 传入 signal
        })

        const idx = currentMessages.findIndex((m) => m.id === aiId)
        if (idx !== -1) {
          currentMessages[idx] = {
            ...currentMessages[idx],
            message: aiReply,
            loading: false,
            scene: scene, // 保持场景信息
          }
        }

        // 更新 Map 中的消息列表
        messagesMap.value.set(activeKey.value, currentMessages)
        // 清空输入内容
        content.value = ''
      } catch (e) {
        // 错误处理
        const idx = currentMessages.findIndex((m) => m.id === aiId)
        if (idx !== -1) {
          // 判断是否是取消请求导致的错误
          const message = e.name === 'CanceledError' ? '您已取消请求。' : 'AI请求失败，请重试'
          currentMessages[idx] = {
            ...currentMessages[idx],
            message,
            loading: false,
            scene: scene, // 保持场景信息
          }
        }
        if (e.name !== 'CanceledError') {
          message.error('AI请求失败')
        }
      } finally {
        requestLoading.value = false
        aiAbortController = null
      }
    }
  }

  const deleteConversationMessages = (key) => {
    messagesMap.value.delete(key)
  }

  const cancelMessage = (isCreatingNewConversation, scene) => {
    console.log('🐯 ~ cancelMessage ~ scene:', scene)
    requestLoading.value = false

    // 如果存在未完成的请求，取消它
    if (aiAbortController) {
      aiAbortController.abort()
      aiAbortController = null
    }

    if (isCreatingNewConversation.value) {
      const idx = tempMessages.value.findIndex((m) => m.role === 'ai' && m.loading)
      if (idx !== -1) {
        tempMessages.value[idx] = {
          ...tempMessages.value[idx],
          message: '您已取消请求。',
          loading: false,
          scene: scene, // 保持场景信息
        }
      }
    } else {
      const currentMessages = getCurrentMessages(activeKey.value)
      const idx = currentMessages.findIndex((m) => m.role === 'ai' && m.loading)
      if (idx !== -1) {
        currentMessages[idx] = {
          ...currentMessages[idx],
          message: '您已取消请求。',
          loading: false,
          scene: scene, // 保持场景信息
        }

        messagesMap.value.set(activeKey.value, currentMessages)
      }
    }
  }

  return {
    messagesMap,
    tempMessages,
    content,
    requestLoading,
    BubbleItems,
    sendMessage,
    cancelMessage,
    deleteConversationMessages,
  }
}
